// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.fba.shipment;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.FbaShipment;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(FbaShipment.class)
@Setter
@Getter
public class FbaShipmentSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "FbaShipment".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("createUser", "su");
    map.put("shop", "si");
    map.put("sendAddress", "fbaa");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();
    map.put(
      "list.productName",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN fba_shipment_product AS RO_1 ON RO_1.del_flag = 0 AND RO_1.parent_fba_shipment = t.id"
        )
        .setTableAlias("RO_1")
        .setColumnName("product_name")
        .setNeedGroupBy(true)
    );
    map.put(
      "list.productName.sku",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN product AS RO_2 ON RO_2.del_flag = 0 AND RO_2.id = RO_1.product_name"
        )
        .setTableAlias("RO_2")
        .setColumnName("sku")
        .setDepends(Collections.singletonList("list.productName"))
    );
    map.put(
      "list.msku",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN fba_shipment_product AS RO_3 ON RO_3.del_flag = 0 AND RO_3.parent_fba_shipment = t.id"
        )
        .setTableAlias("RO_3")
        .setColumnName("msku")
        .setNeedGroupBy(true)
    );

    return map;
  }

  private String list_productName_sku;
  private List<String> list_productName_skuInList;
  private String list_msku;
  private List<String> list_mskuInList;

  /**
   * 指定使用特定的视图过滤条件
   * <p>
   * 有效值包括：FbaShipment/AllData
   * </p>
   */
  private String byViewName;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;
  /**
   * 创建人的显示用户名 比较(eq)
   */
  private String createUserNameEq;
  /**
   * 创建人的显示用户名 比较(neq)
   */
  private String createUserNameNeq;
  /**
   * 创建人的显示用户名 比较(gt)
   */
  private String createUserNameGt;
  /**
   * 创建人的显示用户名 比较(gte)
   */
  private String createUserNameGte;
  /**
   * 创建人的显示用户名 比较(lt)
   */
  private String createUserNameLt;
  /**
   * 创建人的显示用户名 比较(lte)
   */
  private String createUserNameLte;
  /**
   * 创建人的显示用户名 比较(contains)
   */
  private String createUserNameContains;
  /**
   * 创建人的显示用户名 比较(notcontains)
   */
  private String createUserNameNotcontains;
  /**
   * 创建人的显示用户名 比较(startswith)
   */
  private String createUserNameStartswith;
  /**
   * 创建人的显示用户名 比较(endswith)
   */
  private String createUserNameEndswith;
  /**
   * 创建人的显示用户名 比较(isnull)
   */
  private Boolean createUserNameIsnull;
  /**
   * 创建人的显示用户名 比较(isnotnull)
   */
  private Boolean createUserNameIsnotnull;

  /**
   * 创建人(范围搜索)
   */
  private List<Long> createUserInList;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 货件编号(模糊搜索)
   */
  private String shipmentId;

  /**
   * 货件编号 比较(eq)
   */
  private String shipmentIdEq;
  /**
   * 货件编号 比较(neq)
   */
  private String shipmentIdNeq;
  /**
   * 货件编号 比较(gt)
   */
  private String shipmentIdGt;
  /**
   * 货件编号 比较(gte)
   */
  private String shipmentIdGte;
  /**
   * 货件编号 比较(lt)
   */
  private String shipmentIdLt;
  /**
   * 货件编号 比较(lte)
   */
  private String shipmentIdLte;
  /**
   * 货件编号 比较(contains)
   */
  private String shipmentIdContains;
  /**
   * 货件编号 比较(notcontains)
   */
  private String shipmentIdNotcontains;
  /**
   * 货件编号 比较(startswith)
   */
  private String shipmentIdStartswith;
  /**
   * 货件编号 比较(endswith)
   */
  private String shipmentIdEndswith;
  /**
   * 货件编号 比较(isnull)
   */
  private Boolean shipmentIdIsnull;
  /**
   * 货件编号 比较(isnotnull)
   */
  private Boolean shipmentIdIsnotnull;

  /**
   * 货件编号(精确搜索)
   */
  private List<String> shipmentIdInList;

  /**
   * 店铺
   */
  private Long shop;

  /**
   * 店铺 比较(eq)
   */
  private Long shopEq;
  /**
   * 店铺 比较(neq)
   */
  private Long shopNeq;
  /**
   * 店铺 比较(gt)
   */
  private Long shopGt;
  /**
   * 店铺 比较(gte)
   */
  private Long shopGte;
  /**
   * 店铺 比较(lt)
   */
  private Long shopLt;
  /**
   * 店铺 比较(lte)
   */
  private Long shopLte;
  /**
   * 店铺 比较(contains)
   */
  private Long shopContains;
  /**
   * 店铺 比较(notcontains)
   */
  private Long shopNotcontains;
  /**
   * 店铺 比较(startswith)
   */
  private Long shopStartswith;
  /**
   * 店铺 比较(endswith)
   */
  private Long shopEndswith;
  /**
   * 店铺 比较(isnull)
   */
  private Boolean shopIsnull;
  /**
   * 店铺 比较(isnotnull)
   */
  private Boolean shopIsnotnull;
  /**
   * 店铺的名称 比较(eq)
   */
  private String shopShopNameEq;
  /**
   * 店铺的名称 比较(neq)
   */
  private String shopShopNameNeq;
  /**
   * 店铺的名称 比较(gt)
   */
  private String shopShopNameGt;
  /**
   * 店铺的名称 比较(gte)
   */
  private String shopShopNameGte;
  /**
   * 店铺的名称 比较(lt)
   */
  private String shopShopNameLt;
  /**
   * 店铺的名称 比较(lte)
   */
  private String shopShopNameLte;
  /**
   * 店铺的名称 比较(contains)
   */
  private String shopShopNameContains;
  /**
   * 店铺的名称 比较(notcontains)
   */
  private String shopShopNameNotcontains;
  /**
   * 店铺的名称 比较(startswith)
   */
  private String shopShopNameStartswith;
  /**
   * 店铺的名称 比较(endswith)
   */
  private String shopShopNameEndswith;
  /**
   * 店铺的名称 比较(isnull)
   */
  private Boolean shopShopNameIsnull;
  /**
   * 店铺的名称 比较(isnotnull)
   */
  private Boolean shopShopNameIsnotnull;

  /**
   * 店铺(范围搜索)
   */
  private List<Long> shopInList;

  /**
   * 国家(模糊搜索)
   */
  private String country;

  /**
   * 国家 比较(eq)
   */
  private String countryEq;
  /**
   * 国家 比较(neq)
   */
  private String countryNeq;
  /**
   * 国家 比较(gt)
   */
  private String countryGt;
  /**
   * 国家 比较(gte)
   */
  private String countryGte;
  /**
   * 国家 比较(lt)
   */
  private String countryLt;
  /**
   * 国家 比较(lte)
   */
  private String countryLte;
  /**
   * 国家 比较(contains)
   */
  private String countryContains;
  /**
   * 国家 比较(notcontains)
   */
  private String countryNotcontains;
  /**
   * 国家 比较(startswith)
   */
  private String countryStartswith;
  /**
   * 国家 比较(endswith)
   */
  private String countryEndswith;
  /**
   * 国家 比较(isnull)
   */
  private Boolean countryIsnull;
  /**
   * 国家 比较(isnotnull)
   */
  private Boolean countryIsnotnull;

  /**
   * 国家(精确搜索)
   */
  private List<String> countryInList;

  /**
   * 发货地址
   */
  private Long sendAddress;

  /**
   * 发货地址 比较(eq)
   */
  private Long sendAddressEq;
  /**
   * 发货地址 比较(neq)
   */
  private Long sendAddressNeq;
  /**
   * 发货地址 比较(gt)
   */
  private Long sendAddressGt;
  /**
   * 发货地址 比较(gte)
   */
  private Long sendAddressGte;
  /**
   * 发货地址 比较(lt)
   */
  private Long sendAddressLt;
  /**
   * 发货地址 比较(lte)
   */
  private Long sendAddressLte;
  /**
   * 发货地址 比较(contains)
   */
  private Long sendAddressContains;
  /**
   * 发货地址 比较(notcontains)
   */
  private Long sendAddressNotcontains;
  /**
   * 发货地址 比较(startswith)
   */
  private Long sendAddressStartswith;
  /**
   * 发货地址 比较(endswith)
   */
  private Long sendAddressEndswith;
  /**
   * 发货地址 比较(isnull)
   */
  private Boolean sendAddressIsnull;
  /**
   * 发货地址 比较(isnotnull)
   */
  private Boolean sendAddressIsnotnull;
  /**
   * 发货地址的地址别名 比较(eq)
   */
  private String sendAddressAliasEq;
  /**
   * 发货地址的地址别名 比较(neq)
   */
  private String sendAddressAliasNeq;
  /**
   * 发货地址的地址别名 比较(gt)
   */
  private String sendAddressAliasGt;
  /**
   * 发货地址的地址别名 比较(gte)
   */
  private String sendAddressAliasGte;
  /**
   * 发货地址的地址别名 比较(lt)
   */
  private String sendAddressAliasLt;
  /**
   * 发货地址的地址别名 比较(lte)
   */
  private String sendAddressAliasLte;
  /**
   * 发货地址的地址别名 比较(contains)
   */
  private String sendAddressAliasContains;
  /**
   * 发货地址的地址别名 比较(notcontains)
   */
  private String sendAddressAliasNotcontains;
  /**
   * 发货地址的地址别名 比较(startswith)
   */
  private String sendAddressAliasStartswith;
  /**
   * 发货地址的地址别名 比较(endswith)
   */
  private String sendAddressAliasEndswith;
  /**
   * 发货地址的地址别名 比较(isnull)
   */
  private Boolean sendAddressAliasIsnull;
  /**
   * 发货地址的地址别名 比较(isnotnull)
   */
  private Boolean sendAddressAliasIsnotnull;

  /**
   * 发货地址(范围搜索)
   */
  private List<Long> sendAddressInList;

  /**
   * 物流中心编码(模糊搜索)
   */
  private String destinationFulfillmentCenterId;

  /**
   * 物流中心编码 比较(eq)
   */
  private String destinationFulfillmentCenterIdEq;
  /**
   * 物流中心编码 比较(neq)
   */
  private String destinationFulfillmentCenterIdNeq;
  /**
   * 物流中心编码 比较(gt)
   */
  private String destinationFulfillmentCenterIdGt;
  /**
   * 物流中心编码 比较(gte)
   */
  private String destinationFulfillmentCenterIdGte;
  /**
   * 物流中心编码 比较(lt)
   */
  private String destinationFulfillmentCenterIdLt;
  /**
   * 物流中心编码 比较(lte)
   */
  private String destinationFulfillmentCenterIdLte;
  /**
   * 物流中心编码 比较(contains)
   */
  private String destinationFulfillmentCenterIdContains;
  /**
   * 物流中心编码 比较(notcontains)
   */
  private String destinationFulfillmentCenterIdNotcontains;
  /**
   * 物流中心编码 比较(startswith)
   */
  private String destinationFulfillmentCenterIdStartswith;
  /**
   * 物流中心编码 比较(endswith)
   */
  private String destinationFulfillmentCenterIdEndswith;
  /**
   * 物流中心编码 比较(isnull)
   */
  private Boolean destinationFulfillmentCenterIdIsnull;
  /**
   * 物流中心编码 比较(isnotnull)
   */
  private Boolean destinationFulfillmentCenterIdIsnotnull;

  /**
   * 物流中心编码(精确搜索)
   */
  private List<String> destinationFulfillmentCenterIdInList;

  /**
   * 工厂直发
   */
  private String factoryDirectDelivery;

  /**
   * 工厂直发 比较(eq)
   */
  private String factoryDirectDeliveryEq;
  /**
   * 工厂直发 比较(neq)
   */
  private String factoryDirectDeliveryNeq;
  /**
   * 工厂直发 比较(gt)
   */
  private String factoryDirectDeliveryGt;
  /**
   * 工厂直发 比较(gte)
   */
  private String factoryDirectDeliveryGte;
  /**
   * 工厂直发 比较(lt)
   */
  private String factoryDirectDeliveryLt;
  /**
   * 工厂直发 比较(lte)
   */
  private String factoryDirectDeliveryLte;
  /**
   * 工厂直发 比较(contains)
   */
  private String factoryDirectDeliveryContains;
  /**
   * 工厂直发 比较(notcontains)
   */
  private String factoryDirectDeliveryNotcontains;
  /**
   * 工厂直发 比较(startswith)
   */
  private String factoryDirectDeliveryStartswith;
  /**
   * 工厂直发 比较(endswith)
   */
  private String factoryDirectDeliveryEndswith;
  /**
   * 工厂直发 比较(isnull)
   */
  private Boolean factoryDirectDeliveryIsnull;
  /**
   * 工厂直发 比较(isnotnull)
   */
  private Boolean factoryDirectDeliveryIsnotnull;

  /**
   * 工厂直发(精确搜索)
   */
  private List<String> factoryDirectDeliveryInList;

  /**
   * 同步时间(模糊搜索)
   */
  private String syncTime;

  /**
   * 同步时间 比较(eq)
   */
  private String syncTimeEq;
  /**
   * 同步时间 比较(neq)
   */
  private String syncTimeNeq;
  /**
   * 同步时间 比较(gt)
   */
  private String syncTimeGt;
  /**
   * 同步时间 比较(gte)
   */
  private String syncTimeGte;
  /**
   * 同步时间 比较(lt)
   */
  private String syncTimeLt;
  /**
   * 同步时间 比较(lte)
   */
  private String syncTimeLte;
  /**
   * 同步时间 比较(contains)
   */
  private String syncTimeContains;
  /**
   * 同步时间 比较(notcontains)
   */
  private String syncTimeNotcontains;
  /**
   * 同步时间 比较(startswith)
   */
  private String syncTimeStartswith;
  /**
   * 同步时间 比较(endswith)
   */
  private String syncTimeEndswith;
  /**
   * 同步时间 比较(isnull)
   */
  private Boolean syncTimeIsnull;
  /**
   * 同步时间 比较(isnotnull)
   */
  private Boolean syncTimeIsnotnull;

  /**
   * 同步时间(精确搜索)
   */
  private List<String> syncTimeInList;

  /**
   * 货件状态
   */
  private String shipmentStatus;

  /**
   * 货件状态 比较(eq)
   */
  private String shipmentStatusEq;
  /**
   * 货件状态 比较(neq)
   */
  private String shipmentStatusNeq;
  /**
   * 货件状态 比较(gt)
   */
  private String shipmentStatusGt;
  /**
   * 货件状态 比较(gte)
   */
  private String shipmentStatusGte;
  /**
   * 货件状态 比较(lt)
   */
  private String shipmentStatusLt;
  /**
   * 货件状态 比较(lte)
   */
  private String shipmentStatusLte;
  /**
   * 货件状态 比较(contains)
   */
  private String shipmentStatusContains;
  /**
   * 货件状态 比较(notcontains)
   */
  private String shipmentStatusNotcontains;
  /**
   * 货件状态 比较(startswith)
   */
  private String shipmentStatusStartswith;
  /**
   * 货件状态 比较(endswith)
   */
  private String shipmentStatusEndswith;
  /**
   * 货件状态 比较(isnull)
   */
  private Boolean shipmentStatusIsnull;
  /**
   * 货件状态 比较(isnotnull)
   */
  private Boolean shipmentStatusIsnotnull;

  /**
   * 货件状态(精确搜索)
   */
  private List<String> shipmentStatusInList;

  /**
   * 是否已完成状态
   */
  private String isClosed;

  /**
   * 是否已完成状态 比较(eq)
   */
  private String isClosedEq;
  /**
   * 是否已完成状态 比较(neq)
   */
  private String isClosedNeq;
  /**
   * 是否已完成状态 比较(gt)
   */
  private String isClosedGt;
  /**
   * 是否已完成状态 比较(gte)
   */
  private String isClosedGte;
  /**
   * 是否已完成状态 比较(lt)
   */
  private String isClosedLt;
  /**
   * 是否已完成状态 比较(lte)
   */
  private String isClosedLte;
  /**
   * 是否已完成状态 比较(contains)
   */
  private String isClosedContains;
  /**
   * 是否已完成状态 比较(notcontains)
   */
  private String isClosedNotcontains;
  /**
   * 是否已完成状态 比较(startswith)
   */
  private String isClosedStartswith;
  /**
   * 是否已完成状态 比较(endswith)
   */
  private String isClosedEndswith;
  /**
   * 是否已完成状态 比较(isnull)
   */
  private Boolean isClosedIsnull;
  /**
   * 是否已完成状态 比较(isnotnull)
   */
  private Boolean isClosedIsnotnull;

  /**
   * 是否已完成状态(精确搜索)
   */
  private List<String> isClosedInList;

  /**
   * 标签类型
   */
  private String labelType;

  /**
   * 标签类型 比较(eq)
   */
  private String labelTypeEq;
  /**
   * 标签类型 比较(neq)
   */
  private String labelTypeNeq;
  /**
   * 标签类型 比较(gt)
   */
  private String labelTypeGt;
  /**
   * 标签类型 比较(gte)
   */
  private String labelTypeGte;
  /**
   * 标签类型 比较(lt)
   */
  private String labelTypeLt;
  /**
   * 标签类型 比较(lte)
   */
  private String labelTypeLte;
  /**
   * 标签类型 比较(contains)
   */
  private String labelTypeContains;
  /**
   * 标签类型 比较(notcontains)
   */
  private String labelTypeNotcontains;
  /**
   * 标签类型 比较(startswith)
   */
  private String labelTypeStartswith;
  /**
   * 标签类型 比较(endswith)
   */
  private String labelTypeEndswith;
  /**
   * 标签类型 比较(isnull)
   */
  private Boolean labelTypeIsnull;
  /**
   * 标签类型 比较(isnotnull)
   */
  private Boolean labelTypeIsnotnull;

  /**
   * 标签类型(精确搜索)
   */
  private List<String> labelTypeInList;

  /**
   * 货件名称(模糊搜索)
   */
  private String shipmentName;

  /**
   * 货件名称 比较(eq)
   */
  private String shipmentNameEq;
  /**
   * 货件名称 比较(neq)
   */
  private String shipmentNameNeq;
  /**
   * 货件名称 比较(gt)
   */
  private String shipmentNameGt;
  /**
   * 货件名称 比较(gte)
   */
  private String shipmentNameGte;
  /**
   * 货件名称 比较(lt)
   */
  private String shipmentNameLt;
  /**
   * 货件名称 比较(lte)
   */
  private String shipmentNameLte;
  /**
   * 货件名称 比较(contains)
   */
  private String shipmentNameContains;
  /**
   * 货件名称 比较(notcontains)
   */
  private String shipmentNameNotcontains;
  /**
   * 货件名称 比较(startswith)
   */
  private String shipmentNameStartswith;
  /**
   * 货件名称 比较(endswith)
   */
  private String shipmentNameEndswith;
  /**
   * 货件名称 比较(isnull)
   */
  private Boolean shipmentNameIsnull;
  /**
   * 货件名称 比较(isnotnull)
   */
  private Boolean shipmentNameIsnotnull;

  /**
   * 货件名称(精确搜索)
   */
  private List<String> shipmentNameInList;

  /**
   * 包装类型
   */
  private String packingType;

  /**
   * 包装类型 比较(eq)
   */
  private String packingTypeEq;
  /**
   * 包装类型 比较(neq)
   */
  private String packingTypeNeq;
  /**
   * 包装类型 比较(gt)
   */
  private String packingTypeGt;
  /**
   * 包装类型 比较(gte)
   */
  private String packingTypeGte;
  /**
   * 包装类型 比较(lt)
   */
  private String packingTypeLt;
  /**
   * 包装类型 比较(lte)
   */
  private String packingTypeLte;
  /**
   * 包装类型 比较(contains)
   */
  private String packingTypeContains;
  /**
   * 包装类型 比较(notcontains)
   */
  private String packingTypeNotcontains;
  /**
   * 包装类型 比较(startswith)
   */
  private String packingTypeStartswith;
  /**
   * 包装类型 比较(endswith)
   */
  private String packingTypeEndswith;
  /**
   * 包装类型 比较(isnull)
   */
  private Boolean packingTypeIsnull;
  /**
   * 包装类型 比较(isnotnull)
   */
  private Boolean packingTypeIsnotnull;

  /**
   * 包装类型(精确搜索)
   */
  private List<String> packingTypeInList;

  /**
   * 发货单(模糊搜索)
   */
  private String invoiceNo;

  /**
   * 发货单 比较(eq)
   */
  private String invoiceNoEq;
  /**
   * 发货单 比较(neq)
   */
  private String invoiceNoNeq;
  /**
   * 发货单 比较(gt)
   */
  private String invoiceNoGt;
  /**
   * 发货单 比较(gte)
   */
  private String invoiceNoGte;
  /**
   * 发货单 比较(lt)
   */
  private String invoiceNoLt;
  /**
   * 发货单 比较(lte)
   */
  private String invoiceNoLte;
  /**
   * 发货单 比较(contains)
   */
  private String invoiceNoContains;
  /**
   * 发货单 比较(notcontains)
   */
  private String invoiceNoNotcontains;
  /**
   * 发货单 比较(startswith)
   */
  private String invoiceNoStartswith;
  /**
   * 发货单 比较(endswith)
   */
  private String invoiceNoEndswith;
  /**
   * 发货单 比较(isnull)
   */
  private Boolean invoiceNoIsnull;
  /**
   * 发货单 比较(isnotnull)
   */
  private Boolean invoiceNoIsnotnull;

  /**
   * 发货单(精确搜索)
   */
  private List<String> invoiceNoInList;

  /**
   * 集装箱任务单号(模糊搜索)
   */
  private String containertaskNo;

  /**
   * 集装箱任务单号 比较(eq)
   */
  private String containertaskNoEq;
  /**
   * 集装箱任务单号 比较(neq)
   */
  private String containertaskNoNeq;
  /**
   * 集装箱任务单号 比较(gt)
   */
  private String containertaskNoGt;
  /**
   * 集装箱任务单号 比较(gte)
   */
  private String containertaskNoGte;
  /**
   * 集装箱任务单号 比较(lt)
   */
  private String containertaskNoLt;
  /**
   * 集装箱任务单号 比较(lte)
   */
  private String containertaskNoLte;
  /**
   * 集装箱任务单号 比较(contains)
   */
  private String containertaskNoContains;
  /**
   * 集装箱任务单号 比较(notcontains)
   */
  private String containertaskNoNotcontains;
  /**
   * 集装箱任务单号 比较(startswith)
   */
  private String containertaskNoStartswith;
  /**
   * 集装箱任务单号 比较(endswith)
   */
  private String containertaskNoEndswith;
  /**
   * 集装箱任务单号 比较(isnull)
   */
  private Boolean containertaskNoIsnull;
  /**
   * 集装箱任务单号 比较(isnotnull)
   */
  private Boolean containertaskNoIsnotnull;

  /**
   * 集装箱任务单号(精确搜索)
   */
  private List<String> containertaskNoInList;

  /**
   * Reference_ID(模糊搜索)
   */
  private String referenceId;

  /**
   * Reference_ID 比较(eq)
   */
  private String referenceIdEq;
  /**
   * Reference_ID 比较(neq)
   */
  private String referenceIdNeq;
  /**
   * Reference_ID 比较(gt)
   */
  private String referenceIdGt;
  /**
   * Reference_ID 比较(gte)
   */
  private String referenceIdGte;
  /**
   * Reference_ID 比较(lt)
   */
  private String referenceIdLt;
  /**
   * Reference_ID 比较(lte)
   */
  private String referenceIdLte;
  /**
   * Reference_ID 比较(contains)
   */
  private String referenceIdContains;
  /**
   * Reference_ID 比较(notcontains)
   */
  private String referenceIdNotcontains;
  /**
   * Reference_ID 比较(startswith)
   */
  private String referenceIdStartswith;
  /**
   * Reference_ID 比较(endswith)
   */
  private String referenceIdEndswith;
  /**
   * Reference_ID 比较(isnull)
   */
  private Boolean referenceIdIsnull;
  /**
   * Reference_ID 比较(isnotnull)
   */
  private Boolean referenceIdIsnotnull;

  /**
   * Reference_ID(精确搜索)
   */
  private List<String> referenceIdInList;

  /**
   * 发货方名称(模糊搜索)
   */
  private String consignerName;

  /**
   * 发货方名称 比较(eq)
   */
  private String consignerNameEq;
  /**
   * 发货方名称 比较(neq)
   */
  private String consignerNameNeq;
  /**
   * 发货方名称 比较(gt)
   */
  private String consignerNameGt;
  /**
   * 发货方名称 比较(gte)
   */
  private String consignerNameGte;
  /**
   * 发货方名称 比较(lt)
   */
  private String consignerNameLt;
  /**
   * 发货方名称 比较(lte)
   */
  private String consignerNameLte;
  /**
   * 发货方名称 比较(contains)
   */
  private String consignerNameContains;
  /**
   * 发货方名称 比较(notcontains)
   */
  private String consignerNameNotcontains;
  /**
   * 发货方名称 比较(startswith)
   */
  private String consignerNameStartswith;
  /**
   * 发货方名称 比较(endswith)
   */
  private String consignerNameEndswith;
  /**
   * 发货方名称 比较(isnull)
   */
  private Boolean consignerNameIsnull;
  /**
   * 发货方名称 比较(isnotnull)
   */
  private Boolean consignerNameIsnotnull;

  /**
   * 发货方名称(精确搜索)
   */
  private List<String> consignerNameInList;

  /**
   * 电话号码(模糊搜索)
   */
  private String phone;

  /**
   * 电话号码 比较(eq)
   */
  private String phoneEq;
  /**
   * 电话号码 比较(neq)
   */
  private String phoneNeq;
  /**
   * 电话号码 比较(gt)
   */
  private String phoneGt;
  /**
   * 电话号码 比较(gte)
   */
  private String phoneGte;
  /**
   * 电话号码 比较(lt)
   */
  private String phoneLt;
  /**
   * 电话号码 比较(lte)
   */
  private String phoneLte;
  /**
   * 电话号码 比较(contains)
   */
  private String phoneContains;
  /**
   * 电话号码 比较(notcontains)
   */
  private String phoneNotcontains;
  /**
   * 电话号码 比较(startswith)
   */
  private String phoneStartswith;
  /**
   * 电话号码 比较(endswith)
   */
  private String phoneEndswith;
  /**
   * 电话号码 比较(isnull)
   */
  private Boolean phoneIsnull;
  /**
   * 电话号码 比较(isnotnull)
   */
  private Boolean phoneIsnotnull;

  /**
   * 电话号码(精确搜索)
   */
  private List<String> phoneInList;

  /**
   * 发货国家(地区)(模糊搜索)
   */
  private String shipmentsCountry;

  /**
   * 发货国家(地区) 比较(eq)
   */
  private String shipmentsCountryEq;
  /**
   * 发货国家(地区) 比较(neq)
   */
  private String shipmentsCountryNeq;
  /**
   * 发货国家(地区) 比较(gt)
   */
  private String shipmentsCountryGt;
  /**
   * 发货国家(地区) 比较(gte)
   */
  private String shipmentsCountryGte;
  /**
   * 发货国家(地区) 比较(lt)
   */
  private String shipmentsCountryLt;
  /**
   * 发货国家(地区) 比较(lte)
   */
  private String shipmentsCountryLte;
  /**
   * 发货国家(地区) 比较(contains)
   */
  private String shipmentsCountryContains;
  /**
   * 发货国家(地区) 比较(notcontains)
   */
  private String shipmentsCountryNotcontains;
  /**
   * 发货国家(地区) 比较(startswith)
   */
  private String shipmentsCountryStartswith;
  /**
   * 发货国家(地区) 比较(endswith)
   */
  private String shipmentsCountryEndswith;
  /**
   * 发货国家(地区) 比较(isnull)
   */
  private Boolean shipmentsCountryIsnull;
  /**
   * 发货国家(地区) 比较(isnotnull)
   */
  private Boolean shipmentsCountryIsnotnull;

  /**
   * 发货国家(地区)(精确搜索)
   */
  private List<String> shipmentsCountryInList;

  /**
   * 街道地址1(模糊搜索)
   */
  private String streetAddress;

  /**
   * 街道地址1 比较(eq)
   */
  private String streetAddressEq;
  /**
   * 街道地址1 比较(neq)
   */
  private String streetAddressNeq;
  /**
   * 街道地址1 比较(gt)
   */
  private String streetAddressGt;
  /**
   * 街道地址1 比较(gte)
   */
  private String streetAddressGte;
  /**
   * 街道地址1 比较(lt)
   */
  private String streetAddressLt;
  /**
   * 街道地址1 比较(lte)
   */
  private String streetAddressLte;
  /**
   * 街道地址1 比较(contains)
   */
  private String streetAddressContains;
  /**
   * 街道地址1 比较(notcontains)
   */
  private String streetAddressNotcontains;
  /**
   * 街道地址1 比较(startswith)
   */
  private String streetAddressStartswith;
  /**
   * 街道地址1 比较(endswith)
   */
  private String streetAddressEndswith;
  /**
   * 街道地址1 比较(isnull)
   */
  private Boolean streetAddressIsnull;
  /**
   * 街道地址1 比较(isnotnull)
   */
  private Boolean streetAddressIsnotnull;

  /**
   * 街道地址1(精确搜索)
   */
  private List<String> streetAddressInList;

  /**
   * 街道地址2(模糊搜索)
   */
  private String streetAddress2;

  /**
   * 街道地址2 比较(eq)
   */
  private String streetAddress2Eq;
  /**
   * 街道地址2 比较(neq)
   */
  private String streetAddress2Neq;
  /**
   * 街道地址2 比较(gt)
   */
  private String streetAddress2Gt;
  /**
   * 街道地址2 比较(gte)
   */
  private String streetAddress2Gte;
  /**
   * 街道地址2 比较(lt)
   */
  private String streetAddress2Lt;
  /**
   * 街道地址2 比较(lte)
   */
  private String streetAddress2Lte;
  /**
   * 街道地址2 比较(contains)
   */
  private String streetAddress2Contains;
  /**
   * 街道地址2 比较(notcontains)
   */
  private String streetAddress2Notcontains;
  /**
   * 街道地址2 比较(startswith)
   */
  private String streetAddress2Startswith;
  /**
   * 街道地址2 比较(endswith)
   */
  private String streetAddress2Endswith;
  /**
   * 街道地址2 比较(isnull)
   */
  private Boolean streetAddress2Isnull;
  /**
   * 街道地址2 比较(isnotnull)
   */
  private Boolean streetAddress2Isnotnull;

  /**
   * 街道地址2(精确搜索)
   */
  private List<String> streetAddress2InList;

  /**
   * 市(模糊搜索)
   */
  private String city;

  /**
   * 市 比较(eq)
   */
  private String cityEq;
  /**
   * 市 比较(neq)
   */
  private String cityNeq;
  /**
   * 市 比较(gt)
   */
  private String cityGt;
  /**
   * 市 比较(gte)
   */
  private String cityGte;
  /**
   * 市 比较(lt)
   */
  private String cityLt;
  /**
   * 市 比较(lte)
   */
  private String cityLte;
  /**
   * 市 比较(contains)
   */
  private String cityContains;
  /**
   * 市 比较(notcontains)
   */
  private String cityNotcontains;
  /**
   * 市 比较(startswith)
   */
  private String cityStartswith;
  /**
   * 市 比较(endswith)
   */
  private String cityEndswith;
  /**
   * 市 比较(isnull)
   */
  private Boolean cityIsnull;
  /**
   * 市 比较(isnotnull)
   */
  private Boolean cityIsnotnull;

  /**
   * 市(精确搜索)
   */
  private List<String> cityInList;

  /**
   * 区(模糊搜索)
   */
  private String county;

  /**
   * 区 比较(eq)
   */
  private String countyEq;
  /**
   * 区 比较(neq)
   */
  private String countyNeq;
  /**
   * 区 比较(gt)
   */
  private String countyGt;
  /**
   * 区 比较(gte)
   */
  private String countyGte;
  /**
   * 区 比较(lt)
   */
  private String countyLt;
  /**
   * 区 比较(lte)
   */
  private String countyLte;
  /**
   * 区 比较(contains)
   */
  private String countyContains;
  /**
   * 区 比较(notcontains)
   */
  private String countyNotcontains;
  /**
   * 区 比较(startswith)
   */
  private String countyStartswith;
  /**
   * 区 比较(endswith)
   */
  private String countyEndswith;
  /**
   * 区 比较(isnull)
   */
  private Boolean countyIsnull;
  /**
   * 区 比较(isnotnull)
   */
  private Boolean countyIsnotnull;

  /**
   * 区(精确搜索)
   */
  private List<String> countyInList;

  /**
   * 省（洲）(模糊搜索)
   */
  private String province;

  /**
   * 省（洲） 比较(eq)
   */
  private String provinceEq;
  /**
   * 省（洲） 比较(neq)
   */
  private String provinceNeq;
  /**
   * 省（洲） 比较(gt)
   */
  private String provinceGt;
  /**
   * 省（洲） 比较(gte)
   */
  private String provinceGte;
  /**
   * 省（洲） 比较(lt)
   */
  private String provinceLt;
  /**
   * 省（洲） 比较(lte)
   */
  private String provinceLte;
  /**
   * 省（洲） 比较(contains)
   */
  private String provinceContains;
  /**
   * 省（洲） 比较(notcontains)
   */
  private String provinceNotcontains;
  /**
   * 省（洲） 比较(startswith)
   */
  private String provinceStartswith;
  /**
   * 省（洲） 比较(endswith)
   */
  private String provinceEndswith;
  /**
   * 省（洲） 比较(isnull)
   */
  private Boolean provinceIsnull;
  /**
   * 省（洲） 比较(isnotnull)
   */
  private Boolean provinceIsnotnull;

  /**
   * 省（洲）(精确搜索)
   */
  private List<String> provinceInList;

  /**
   * 邮编(模糊搜索)
   */
  private String postcode;

  /**
   * 邮编 比较(eq)
   */
  private String postcodeEq;
  /**
   * 邮编 比较(neq)
   */
  private String postcodeNeq;
  /**
   * 邮编 比较(gt)
   */
  private String postcodeGt;
  /**
   * 邮编 比较(gte)
   */
  private String postcodeGte;
  /**
   * 邮编 比较(lt)
   */
  private String postcodeLt;
  /**
   * 邮编 比较(lte)
   */
  private String postcodeLte;
  /**
   * 邮编 比较(contains)
   */
  private String postcodeContains;
  /**
   * 邮编 比较(notcontains)
   */
  private String postcodeNotcontains;
  /**
   * 邮编 比较(startswith)
   */
  private String postcodeStartswith;
  /**
   * 邮编 比较(endswith)
   */
  private String postcodeEndswith;
  /**
   * 邮编 比较(isnull)
   */
  private Boolean postcodeIsnull;
  /**
   * 邮编 比较(isnotnull)
   */
  private Boolean postcodeIsnotnull;

  /**
   * 邮编(精确搜索)
   */
  private List<String> postcodeInList;

  /**
   * 备注(模糊搜索)
   */
  private String remark;

  /**
   * 备注 比较(eq)
   */
  private String remarkEq;
  /**
   * 备注 比较(neq)
   */
  private String remarkNeq;
  /**
   * 备注 比较(gt)
   */
  private String remarkGt;
  /**
   * 备注 比较(gte)
   */
  private String remarkGte;
  /**
   * 备注 比较(lt)
   */
  private String remarkLt;
  /**
   * 备注 比较(lte)
   */
  private String remarkLte;
  /**
   * 备注 比较(contains)
   */
  private String remarkContains;
  /**
   * 备注 比较(notcontains)
   */
  private String remarkNotcontains;
  /**
   * 备注 比较(startswith)
   */
  private String remarkStartswith;
  /**
   * 备注 比较(endswith)
   */
  private String remarkEndswith;
  /**
   * 备注 比较(isnull)
   */
  private Boolean remarkIsnull;
  /**
   * 备注 比较(isnotnull)
   */
  private Boolean remarkIsnotnull;

  /**
   * 备注(精确搜索)
   */
  private List<String> remarkInList;

  /**
   * 是否从亚马逊后台同步还是erp创建，0：erp创建，1：亚马逊同步
   */
  private String isSynchronous;

  /**
   * 是否从亚马逊后台同步还是erp创建，0：erp创建，1：亚马逊同步 比较(eq)
   */
  private String isSynchronousEq;
  /**
   * 是否从亚马逊后台同步还是erp创建，0：erp创建，1：亚马逊同步 比较(neq)
   */
  private String isSynchronousNeq;
  /**
   * 是否从亚马逊后台同步还是erp创建，0：erp创建，1：亚马逊同步 比较(gt)
   */
  private String isSynchronousGt;
  /**
   * 是否从亚马逊后台同步还是erp创建，0：erp创建，1：亚马逊同步 比较(gte)
   */
  private String isSynchronousGte;
  /**
   * 是否从亚马逊后台同步还是erp创建，0：erp创建，1：亚马逊同步 比较(lt)
   */
  private String isSynchronousLt;
  /**
   * 是否从亚马逊后台同步还是erp创建，0：erp创建，1：亚马逊同步 比较(lte)
   */
  private String isSynchronousLte;
  /**
   * 是否从亚马逊后台同步还是erp创建，0：erp创建，1：亚马逊同步 比较(contains)
   */
  private String isSynchronousContains;
  /**
   * 是否从亚马逊后台同步还是erp创建，0：erp创建，1：亚马逊同步 比较(notcontains)
   */
  private String isSynchronousNotcontains;
  /**
   * 是否从亚马逊后台同步还是erp创建，0：erp创建，1：亚马逊同步 比较(startswith)
   */
  private String isSynchronousStartswith;
  /**
   * 是否从亚马逊后台同步还是erp创建，0：erp创建，1：亚马逊同步 比较(endswith)
   */
  private String isSynchronousEndswith;
  /**
   * 是否从亚马逊后台同步还是erp创建，0：erp创建，1：亚马逊同步 比较(isnull)
   */
  private Boolean isSynchronousIsnull;
  /**
   * 是否从亚马逊后台同步还是erp创建，0：erp创建，1：亚马逊同步 比较(isnotnull)
   */
  private Boolean isSynchronousIsnotnull;

  /**
   * 是否从亚马逊后台同步还是erp创建，0：erp创建，1：亚马逊同步(精确搜索)
   */
  private List<String> isSynchronousInList;

  /**
   * 是否上传了装箱信息
   */
  private String isUploadedBox;

  /**
   * 是否上传了装箱信息 比较(eq)
   */
  private String isUploadedBoxEq;
  /**
   * 是否上传了装箱信息 比较(neq)
   */
  private String isUploadedBoxNeq;
  /**
   * 是否上传了装箱信息 比较(gt)
   */
  private String isUploadedBoxGt;
  /**
   * 是否上传了装箱信息 比较(gte)
   */
  private String isUploadedBoxGte;
  /**
   * 是否上传了装箱信息 比较(lt)
   */
  private String isUploadedBoxLt;
  /**
   * 是否上传了装箱信息 比较(lte)
   */
  private String isUploadedBoxLte;
  /**
   * 是否上传了装箱信息 比较(contains)
   */
  private String isUploadedBoxContains;
  /**
   * 是否上传了装箱信息 比较(notcontains)
   */
  private String isUploadedBoxNotcontains;
  /**
   * 是否上传了装箱信息 比较(startswith)
   */
  private String isUploadedBoxStartswith;
  /**
   * 是否上传了装箱信息 比较(endswith)
   */
  private String isUploadedBoxEndswith;
  /**
   * 是否上传了装箱信息 比较(isnull)
   */
  private Boolean isUploadedBoxIsnull;
  /**
   * 是否上传了装箱信息 比较(isnotnull)
   */
  private Boolean isUploadedBoxIsnotnull;

  /**
   * 是否上传了装箱信息(精确搜索)
   */
  private List<String> isUploadedBoxInList;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date workingTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date workingTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date workingTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date workingTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date workingTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date workingTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date workingTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date workingTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date workingTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date workingTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date workingTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date workingTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean workingTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean workingTimeIsnotnull;

  /**
   * 最早发货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date shippedTimeStart;

  /**
   * 最晚发货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date shippedTimeEnd;

  /**
   * 发货时间 比较(eq)
   */
  private Date shippedTimeEq;
  /**
   * 发货时间 比较(neq)
   */
  private Date shippedTimeNeq;
  /**
   * 发货时间 比较(gt)
   */
  private Date shippedTimeGt;
  /**
   * 发货时间 比较(gte)
   */
  private Date shippedTimeGte;
  /**
   * 发货时间 比较(lt)
   */
  private Date shippedTimeLt;
  /**
   * 发货时间 比较(lte)
   */
  private Date shippedTimeLte;
  /**
   * 发货时间 比较(contains)
   */
  private Date shippedTimeContains;
  /**
   * 发货时间 比较(notcontains)
   */
  private Date shippedTimeNotcontains;
  /**
   * 发货时间 比较(startswith)
   */
  private Date shippedTimeStartswith;
  /**
   * 发货时间 比较(endswith)
   */
  private Date shippedTimeEndswith;
  /**
   * 发货时间 比较(isnull)
   */
  private Boolean shippedTimeIsnull;
  /**
   * 发货时间 比较(isnotnull)
   */
  private Boolean shippedTimeIsnotnull;

  /**
   * 最早签收时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date receivingTimeStart;

  /**
   * 最晚签收时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date receivingTimeEnd;

  /**
   * 签收时间 比较(eq)
   */
  private Date receivingTimeEq;
  /**
   * 签收时间 比较(neq)
   */
  private Date receivingTimeNeq;
  /**
   * 签收时间 比较(gt)
   */
  private Date receivingTimeGt;
  /**
   * 签收时间 比较(gte)
   */
  private Date receivingTimeGte;
  /**
   * 签收时间 比较(lt)
   */
  private Date receivingTimeLt;
  /**
   * 签收时间 比较(lte)
   */
  private Date receivingTimeLte;
  /**
   * 签收时间 比较(contains)
   */
  private Date receivingTimeContains;
  /**
   * 签收时间 比较(notcontains)
   */
  private Date receivingTimeNotcontains;
  /**
   * 签收时间 比较(startswith)
   */
  private Date receivingTimeStartswith;
  /**
   * 签收时间 比较(endswith)
   */
  private Date receivingTimeEndswith;
  /**
   * 签收时间 比较(isnull)
   */
  private Boolean receivingTimeIsnull;
  /**
   * 签收时间 比较(isnotnull)
   */
  private Boolean receivingTimeIsnotnull;

  /**
   * 最早完成时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date closedTimeStart;

  /**
   * 最晚完成时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date closedTimeEnd;

  /**
   * 完成时间 比较(eq)
   */
  private Date closedTimeEq;
  /**
   * 完成时间 比较(neq)
   */
  private Date closedTimeNeq;
  /**
   * 完成时间 比较(gt)
   */
  private Date closedTimeGt;
  /**
   * 完成时间 比较(gte)
   */
  private Date closedTimeGte;
  /**
   * 完成时间 比较(lt)
   */
  private Date closedTimeLt;
  /**
   * 完成时间 比较(lte)
   */
  private Date closedTimeLte;
  /**
   * 完成时间 比较(contains)
   */
  private Date closedTimeContains;
  /**
   * 完成时间 比较(notcontains)
   */
  private Date closedTimeNotcontains;
  /**
   * 完成时间 比较(startswith)
   */
  private Date closedTimeStartswith;
  /**
   * 完成时间 比较(endswith)
   */
  private Date closedTimeEndswith;
  /**
   * 完成时间 比较(isnull)
   */
  private Boolean closedTimeIsnull;
  /**
   * 完成时间 比较(isnotnull)
   */
  private Boolean closedTimeIsnotnull;

  /**
   * 配送地址(模糊搜索)
   */
  private String shippingAddress;

  /**
   * 配送地址 比较(eq)
   */
  private String shippingAddressEq;
  /**
   * 配送地址 比较(neq)
   */
  private String shippingAddressNeq;
  /**
   * 配送地址 比较(gt)
   */
  private String shippingAddressGt;
  /**
   * 配送地址 比较(gte)
   */
  private String shippingAddressGte;
  /**
   * 配送地址 比较(lt)
   */
  private String shippingAddressLt;
  /**
   * 配送地址 比较(lte)
   */
  private String shippingAddressLte;
  /**
   * 配送地址 比较(contains)
   */
  private String shippingAddressContains;
  /**
   * 配送地址 比较(notcontains)
   */
  private String shippingAddressNotcontains;
  /**
   * 配送地址 比较(startswith)
   */
  private String shippingAddressStartswith;
  /**
   * 配送地址 比较(endswith)
   */
  private String shippingAddressEndswith;
  /**
   * 配送地址 比较(isnull)
   */
  private Boolean shippingAddressIsnull;
  /**
   * 配送地址 比较(isnotnull)
   */
  private Boolean shippingAddressIsnotnull;

  /**
   * 配送地址(精确搜索)
   */
  private List<String> shippingAddressInList;

  /**
   * 店铺名称(模糊搜索)
   */
  private String shopName;

  /**
   * 店铺名称 比较(eq)
   */
  private String shopNameEq;
  /**
   * 店铺名称 比较(neq)
   */
  private String shopNameNeq;
  /**
   * 店铺名称 比较(gt)
   */
  private String shopNameGt;
  /**
   * 店铺名称 比较(gte)
   */
  private String shopNameGte;
  /**
   * 店铺名称 比较(lt)
   */
  private String shopNameLt;
  /**
   * 店铺名称 比较(lte)
   */
  private String shopNameLte;
  /**
   * 店铺名称 比较(contains)
   */
  private String shopNameContains;
  /**
   * 店铺名称 比较(notcontains)
   */
  private String shopNameNotcontains;
  /**
   * 店铺名称 比较(startswith)
   */
  private String shopNameStartswith;
  /**
   * 店铺名称 比较(endswith)
   */
  private String shopNameEndswith;
  /**
   * 店铺名称 比较(isnull)
   */
  private Boolean shopNameIsnull;
  /**
   * 店铺名称 比较(isnotnull)
   */
  private Boolean shopNameIsnotnull;

  /**
   * 店铺名称(精确搜索)
   */
  private List<String> shopNameInList;

  /**
   * 货件类型
   */
  private String shipmenttype;

  /**
   * 货件类型 比较(eq)
   */
  private String shipmenttypeEq;
  /**
   * 货件类型 比较(neq)
   */
  private String shipmenttypeNeq;
  /**
   * 货件类型 比较(gt)
   */
  private String shipmenttypeGt;
  /**
   * 货件类型 比较(gte)
   */
  private String shipmenttypeGte;
  /**
   * 货件类型 比较(lt)
   */
  private String shipmenttypeLt;
  /**
   * 货件类型 比较(lte)
   */
  private String shipmenttypeLte;
  /**
   * 货件类型 比较(contains)
   */
  private String shipmenttypeContains;
  /**
   * 货件类型 比较(notcontains)
   */
  private String shipmenttypeNotcontains;
  /**
   * 货件类型 比较(startswith)
   */
  private String shipmenttypeStartswith;
  /**
   * 货件类型 比较(endswith)
   */
  private String shipmenttypeEndswith;
  /**
   * 货件类型 比较(isnull)
   */
  private Boolean shipmenttypeIsnull;
  /**
   * 货件类型 比较(isnotnull)
   */
  private Boolean shipmenttypeIsnotnull;

  /**
   * 货件类型(精确搜索)
   */
  private List<String> shipmenttypeInList;

  /**
   * 承运人
   */
  private String carrier;

  /**
   * 承运人 比较(eq)
   */
  private String carrierEq;
  /**
   * 承运人 比较(neq)
   */
  private String carrierNeq;
  /**
   * 承运人 比较(gt)
   */
  private String carrierGt;
  /**
   * 承运人 比较(gte)
   */
  private String carrierGte;
  /**
   * 承运人 比较(lt)
   */
  private String carrierLt;
  /**
   * 承运人 比较(lte)
   */
  private String carrierLte;
  /**
   * 承运人 比较(contains)
   */
  private String carrierContains;
  /**
   * 承运人 比较(notcontains)
   */
  private String carrierNotcontains;
  /**
   * 承运人 比较(startswith)
   */
  private String carrierStartswith;
  /**
   * 承运人 比较(endswith)
   */
  private String carrierEndswith;
  /**
   * 承运人 比较(isnull)
   */
  private Boolean carrierIsnull;
  /**
   * 承运人 比较(isnotnull)
   */
  private Boolean carrierIsnotnull;

  /**
   * 承运人(精确搜索)
   */
  private List<String> carrierInList;

  /**
   * 承运方式
   */
  private String transportmethod;

  /**
   * 承运方式 比较(eq)
   */
  private String transportmethodEq;
  /**
   * 承运方式 比较(neq)
   */
  private String transportmethodNeq;
  /**
   * 承运方式 比较(gt)
   */
  private String transportmethodGt;
  /**
   * 承运方式 比较(gte)
   */
  private String transportmethodGte;
  /**
   * 承运方式 比较(lt)
   */
  private String transportmethodLt;
  /**
   * 承运方式 比较(lte)
   */
  private String transportmethodLte;
  /**
   * 承运方式 比较(contains)
   */
  private String transportmethodContains;
  /**
   * 承运方式 比较(notcontains)
   */
  private String transportmethodNotcontains;
  /**
   * 承运方式 比较(startswith)
   */
  private String transportmethodStartswith;
  /**
   * 承运方式 比较(endswith)
   */
  private String transportmethodEndswith;
  /**
   * 承运方式 比较(isnull)
   */
  private Boolean transportmethodIsnull;
  /**
   * 承运方式 比较(isnotnull)
   */
  private Boolean transportmethodIsnotnull;

  /**
   * 承运方式(精确搜索)
   */
  private List<String> transportmethodInList;

  /**
   * 装箱上传渠道
   */
  private String packinguploadchannel;

  /**
   * 装箱上传渠道 比较(eq)
   */
  private String packinguploadchannelEq;
  /**
   * 装箱上传渠道 比较(neq)
   */
  private String packinguploadchannelNeq;
  /**
   * 装箱上传渠道 比较(gt)
   */
  private String packinguploadchannelGt;
  /**
   * 装箱上传渠道 比较(gte)
   */
  private String packinguploadchannelGte;
  /**
   * 装箱上传渠道 比较(lt)
   */
  private String packinguploadchannelLt;
  /**
   * 装箱上传渠道 比较(lte)
   */
  private String packinguploadchannelLte;
  /**
   * 装箱上传渠道 比较(contains)
   */
  private String packinguploadchannelContains;
  /**
   * 装箱上传渠道 比较(notcontains)
   */
  private String packinguploadchannelNotcontains;
  /**
   * 装箱上传渠道 比较(startswith)
   */
  private String packinguploadchannelStartswith;
  /**
   * 装箱上传渠道 比较(endswith)
   */
  private String packinguploadchannelEndswith;
  /**
   * 装箱上传渠道 比较(isnull)
   */
  private Boolean packinguploadchannelIsnull;
  /**
   * 装箱上传渠道 比较(isnotnull)
   */
  private Boolean packinguploadchannelIsnotnull;

  /**
   * 装箱上传渠道(精确搜索)
   */
  private List<String> packinguploadchannelInList;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
